home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / bin_c / compile_to_c8.c < prev    next >
C/C++ Source or Header  |  1998-12-22  |  26KB  |  1,268 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.79)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_c.h"
  9.  
  10.  
  11. void r390with_capacity(T390* C,T2 a1){
  12. /*[IF*/
  13. if(((C)->_capacity/*8*/)<(a1)){
  14. C->_storage=calloc(a1,sizeof(T0*));
  15. C->_capacity=a1;
  16. }
  17. /*FI]*/
  18. C->_upper=-(1);
  19. }
  20. /*No:FIXED_ARRAY[RUN_FEATURE_5].clear_all*/
  21.  
  22.  
  23. void r390add_last(T390* C,T0* a1){
  24. T2 _new_capacity=0;
  25. /*[IF*/
  26. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  27. C->_upper=((C)->_upper/*12*/)+(1);
  28. }
  29.  else if(((C)->_capacity/*8*/)==(0)){
  30. C->_storage=calloc(2,sizeof(T0*));
  31. C->_capacity=2;
  32. C->_upper=0;
  33. }
  34. else{
  35. _new_capacity=(2)*((C)->_capacity/*8*/);
  36. C->_storage=r391realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  37. C->_capacity=_new_capacity;
  38. C->_upper=((C)->_upper/*12*/)+(1);
  39. }
  40. /*FI]*/
  41. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  42. /*]*/
  43. }
  44. /*No:FIXED_ARRAY[RUN_FEATURE_5].item*/
  45. /*No:FIXED_ARRAY[RUN_FEATURE_5].set_all_with*/
  46.  
  47.  
  48. T6 r390valid_index(T390* C,T2 a1){
  49. T6 R=0;
  50. R=((0)<=(a1))&&((a1)<=((C)->_upper/*12*/));
  51. return R;
  52. }
  53. /*No:FIXED_ARRAY[RUN_FEATURE_5].count*/
  54. /*No:FIXED_ARRAY[RUN_FEATURE_5].lower*/
  55.  
  56.  
  57. void r390resize(T390* C,T2 a1){
  58. T0* _elt_default=NULL;
  59. T2 _i=0;
  60. T2 _new_capacity=0;
  61. /*[IF*/
  62. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  63. C->_upper=(a1)-(1);
  64. }
  65. else{
  66. _new_capacity=a1;
  67. /*[IF*/
  68. if(((C)->_capacity/*8*/)<(_new_capacity)){
  69. /*[IF*/
  70. if(((C)->_capacity/*8*/)==(0)){
  71. C->_storage=calloc(_new_capacity,sizeof(T0*));
  72. }
  73. else{
  74. C->_storage=r391realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  75. }
  76. /*FI]*/
  77. C->_capacity=_new_capacity;
  78. }
  79. /*FI]*/
  80. _new_capacity=(C)->_upper/*12*/;
  81. C->_upper=(a1)-(1);
  82. _i=(C)->_upper/*12*/;
  83. while (!((_i)==(_new_capacity))) {
  84. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  85. /*]*/
  86. _i=(_i)-(1);
  87. }
  88. }
  89. /*FI]*/
  90. }
  91.  
  92.  
  93. void r390make(T390* C,T2 a1){
  94. /*[IF*/
  95. if((a1)==(0)){
  96. C->_upper=-(1);
  97. }
  98.  else if(((C)->_capacity/*8*/)==(0)){
  99. C->_storage=calloc(a1,sizeof(T0*));
  100. C->_capacity=a1;
  101. C->_upper=(a1)-(1);
  102. }
  103.  else if(((C)->_capacity/*8*/)<(a1)){
  104. C->_storage=calloc(a1,sizeof(T0*));
  105. C->_capacity=a1;
  106. C->_upper=(a1)-(1);
  107. }
  108. else{
  109. C->_upper=(a1)-(1);
  110. /*[IRF3.6clear_all*/{T390* C1=C;
  111. T0* __value=NULL;
  112. /*[IRF3.6set_all_with*/{T390* C2=C1;
  113. T0* c1=__value;
  114. r391set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  115. }/*]*/
  116. }/*]*/
  117. }
  118. /*FI]*/
  119. }
  120.  
  121.  
  122. T6 r390fast_has(T390* C,T0* a1){
  123. T6 R=0;
  124. R=r390valid_index(C,r390fast_index_of(C,a1));
  125. return R;
  126. }
  127.  
  128.  
  129. T2 r390fast_index_of(T390* C,T0* a1){
  130. T2 R=0;
  131. R=r391fast_index_of((C)->_storage/*4*/,a1,(C)->_upper/*12*/);
  132. return R;
  133. }
  134. /*No:FIXED_ARRAY[RUN_FEATURE_5].upper*/
  135. /*No:FIXED_ARRAY[RUN_FEATURE_5].clear*/
  136. /*No:FIXED_ARRAY[RUN_FEATURE_5].capacity*/
  137. /*No:FIXED_ARRAY[RUN_FEATURE_5].put*/
  138. /*No:FIXED_ARRAY[RUN_FEATURE_5].storage*/
  139.  
  140.  
  141. void r385with_capacity(T385* C,T2 a1){
  142. /*[IF*/
  143. if(((C)->_capacity/*8*/)<(a1)){
  144. C->_storage=calloc(a1,sizeof(T0*));
  145. C->_capacity=a1;
  146. }
  147. /*FI]*/
  148. C->_upper=-(1);
  149. }
  150. /*No:FIXED_ARRAY[RUN_FEATURE_2].clear_all*/
  151.  
  152.  
  153. void r385add_last(T385* C,T0* a1){
  154. T2 _new_capacity=0;
  155. /*[IF*/
  156. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  157. C->_upper=((C)->_upper/*12*/)+(1);
  158. }
  159.  else if(((C)->_capacity/*8*/)==(0)){
  160. C->_storage=calloc(2,sizeof(T0*));
  161. C->_capacity=2;
  162. C->_upper=0;
  163. }
  164. else{
  165. _new_capacity=(2)*((C)->_capacity/*8*/);
  166. C->_storage=r362realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  167. C->_capacity=_new_capacity;
  168. C->_upper=((C)->_upper/*12*/)+(1);
  169. }
  170. /*FI]*/
  171. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  172. /*]*/
  173. }
  174. /*No:FIXED_ARRAY[RUN_FEATURE_2].set_all_with*/
  175. /*No:FIXED_ARRAY[RUN_FEATURE_2].item*/
  176.  
  177.  
  178. T6 r385valid_index(T385* C,T2 a1){
  179. T6 R=0;
  180. R=((0)<=(a1))&&((a1)<=((C)->_upper/*12*/));
  181. return R;
  182. }
  183. /*No:FIXED_ARRAY[RUN_FEATURE_2].lower*/
  184. /*No:FIXED_ARRAY[RUN_FEATURE_2].count*/
  185.  
  186.  
  187. void r385resize(T385* C,T2 a1){
  188. T0* _elt_default=NULL;
  189. T2 _i=0;
  190. T2 _new_capacity=0;
  191. /*[IF*/
  192. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  193. C->_upper=(a1)-(1);
  194. }
  195. else{
  196. _new_capacity=a1;
  197. /*[IF*/
  198. if(((C)->_capacity/*8*/)<(_new_capacity)){
  199. /*[IF*/
  200. if(((C)->_capacity/*8*/)==(0)){
  201. C->_storage=calloc(_new_capacity,sizeof(T0*));
  202. }
  203. else{
  204. C->_storage=r362realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  205. }
  206. /*FI]*/
  207. C->_capacity=_new_capacity;
  208. }
  209. /*FI]*/
  210. _new_capacity=(C)->_upper/*12*/;
  211. C->_upper=(a1)-(1);
  212. _i=(C)->_upper/*12*/;
  213. while (!((_i)==(_new_capacity))) {
  214. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  215. /*]*/
  216. _i=(_i)-(1);
  217. }
  218. }
  219. /*FI]*/
  220. }
  221.  
  222.  
  223. void r385make(T385* C,T2 a1){
  224. /*[IF*/
  225. if((a1)==(0)){
  226. C->_upper=-(1);
  227. }
  228.  else if(((C)->_capacity/*8*/)==(0)){
  229. C->_storage=calloc(a1,sizeof(T0*));
  230. C->_capacity=a1;
  231. C->_upper=(a1)-(1);
  232. }
  233.  else if(((C)->_capacity/*8*/)<(a1)){
  234. C->_storage=calloc(a1,sizeof(T0*));
  235. C->_capacity=a1;
  236. C->_upper=(a1)-(1);
  237. }
  238. else{
  239. C->_upper=(a1)-(1);
  240. /*[IRF3.6clear_all*/{T385* C1=C;
  241. T0* __value=NULL;
  242. /*[IRF3.6set_all_with*/{T385* C2=C1;
  243. T0* c1=__value;
  244. r362set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  245. }/*]*/
  246. }/*]*/
  247. }
  248. /*FI]*/
  249. }
  250.  
  251.  
  252. T6 r385fast_has(T385* C,T0* a1){
  253. T6 R=0;
  254. R=r385valid_index(C,r385fast_index_of(C,a1));
  255. return R;
  256. }
  257.  
  258.  
  259. T2 r385fast_index_of(T385* C,T0* a1){
  260. T2 R=0;
  261. R=r362fast_index_of((C)->_storage/*4*/,a1,(C)->_upper/*12*/);
  262. return R;
  263. }
  264. /*No:FIXED_ARRAY[RUN_FEATURE_2].upper*/
  265. /*No:FIXED_ARRAY[RUN_FEATURE_2].clear*/
  266.  
  267.  
  268. T6 r385empty(T385* C){
  269. T6 R=0;
  270. R=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)==(0);
  271. return R;
  272. }
  273. /*No:FIXED_ARRAY[RUN_FEATURE_2].capacity*/
  274. /*No:FIXED_ARRAY[RUN_FEATURE_2].put*/
  275. /*No:FIXED_ARRAY[RUN_FEATURE_2].storage*/
  276.  
  277.  
  278. void r367with_capacity(T367* C,T2 a1){
  279. /*[IF*/
  280. if(((C)->_capacity/*8*/)<(a1)){
  281. C->_storage=calloc(a1,sizeof(T0*));
  282. C->_capacity=a1;
  283. }
  284. /*FI]*/
  285. C->_upper=-(1);
  286. }
  287. /*No:FIXED_ARRAY[RUN_FEATURE_9].clear_all*/
  288.  
  289.  
  290. void r367add_last(T367* C,T0* a1){
  291. T2 _new_capacity=0;
  292. /*[IF*/
  293. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  294. C->_upper=((C)->_upper/*12*/)+(1);
  295. }
  296.  else if(((C)->_capacity/*8*/)==(0)){
  297. C->_storage=calloc(2,sizeof(T0*));
  298. C->_capacity=2;
  299. C->_upper=0;
  300. }
  301. else{
  302. _new_capacity=(2)*((C)->_capacity/*8*/);
  303. C->_storage=r369realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  304. C->_capacity=_new_capacity;
  305. C->_upper=((C)->_upper/*12*/)+(1);
  306. }
  307. /*FI]*/
  308. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  309. /*]*/
  310. }
  311. /*No:FIXED_ARRAY[RUN_FEATURE_9].set_all_with*/
  312. /*No:FIXED_ARRAY[RUN_FEATURE_9].item*/
  313.  
  314.  
  315. T6 r367valid_index(T367* C,T2 a1){
  316. T6 R=0;
  317. R=((0)<=(a1))&&((a1)<=((C)->_upper/*12*/));
  318. return R;
  319. }
  320. /*No:FIXED_ARRAY[RUN_FEATURE_9].count*/
  321. /*No:FIXED_ARRAY[RUN_FEATURE_9].lower*/
  322.  
  323.  
  324. void r367resize(T367* C,T2 a1){
  325. T0* _elt_default=NULL;
  326. T2 _i=0;
  327. T2 _new_capacity=0;
  328. /*[IF*/
  329. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  330. C->_upper=(a1)-(1);
  331. }
  332. else{
  333. _new_capacity=a1;
  334. /*[IF*/
  335. if(((C)->_capacity/*8*/)<(_new_capacity)){
  336. /*[IF*/
  337. if(((C)->_capacity/*8*/)==(0)){
  338. C->_storage=calloc(_new_capacity,sizeof(T0*));
  339. }
  340. else{
  341. C->_storage=r369realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  342. }
  343. /*FI]*/
  344. C->_capacity=_new_capacity;
  345. }
  346. /*FI]*/
  347. _new_capacity=(C)->_upper/*12*/;
  348. C->_upper=(a1)-(1);
  349. _i=(C)->_upper/*12*/;
  350. while (!((_i)==(_new_capacity))) {
  351. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  352. /*]*/
  353. _i=(_i)-(1);
  354. }
  355. }
  356. /*FI]*/
  357. }
  358.  
  359.  
  360. void r367make(T367* C,T2 a1){
  361. /*[IF*/
  362. if((a1)==(0)){
  363. C->_upper=-(1);
  364. }
  365.  else if(((C)->_capacity/*8*/)==(0)){
  366. C->_storage=calloc(a1,sizeof(T0*));
  367. C->_capacity=a1;
  368. C->_upper=(a1)-(1);
  369. }
  370.  else if(((C)->_capacity/*8*/)<(a1)){
  371. C->_storage=calloc(a1,sizeof(T0*));
  372. C->_capacity=a1;
  373. C->_upper=(a1)-(1);
  374. }
  375. else{
  376. C->_upper=(a1)-(1);
  377. /*[IRF3.6clear_all*/{T367* C1=C;
  378. T0* __value=NULL;
  379. /*[IRF3.6set_all_with*/{T367* C2=C1;
  380. T0* c1=__value;
  381. r369set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  382. }/*]*/
  383. }/*]*/
  384. }
  385. /*FI]*/
  386. }
  387.  
  388.  
  389. T6 r367fast_has(T367* C,T0* a1){
  390. T6 R=0;
  391. R=r367valid_index(C,r367fast_index_of(C,a1));
  392. return R;
  393. }
  394.  
  395.  
  396. T2 r367fast_index_of(T367* C,T0* a1){
  397. T2 R=0;
  398. R=r369fast_index_of((C)->_storage/*4*/,a1,(C)->_upper/*12*/);
  399. return R;
  400. }
  401. /*No:FIXED_ARRAY[RUN_FEATURE_9].upper*/
  402. /*No:FIXED_ARRAY[RUN_FEATURE_9].clear*/
  403. /*No:FIXED_ARRAY[RUN_FEATURE_9].capacity*/
  404. /*No:FIXED_ARRAY[RUN_FEATURE_9].put*/
  405. /*No:FIXED_ARRAY[RUN_FEATURE_9].storage*/
  406.  
  407.  
  408. void r352with_capacity(T352* C,T2 a1){
  409. /*[IF*/
  410. if(((C)->_capacity/*8*/)<(a1)){
  411. C->_storage=calloc(a1,sizeof(T0*));
  412. C->_capacity=a1;
  413. }
  414. /*FI]*/
  415. C->_upper=-(1);
  416. }
  417. /*No:FIXED_ARRAY[RUN_FEATURE_3].clear_all*/
  418.  
  419.  
  420. void r352add_last(T352* C,T0* a1){
  421. T2 _new_capacity=0;
  422. /*[IF*/
  423. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  424. C->_upper=((C)->_upper/*12*/)+(1);
  425. }
  426.  else if(((C)->_capacity/*8*/)==(0)){
  427. C->_storage=calloc(2,sizeof(T0*));
  428. C->_capacity=2;
  429. C->_upper=0;
  430. }
  431. else{
  432. _new_capacity=(2)*((C)->_capacity/*8*/);
  433. C->_storage=r353realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  434. C->_capacity=_new_capacity;
  435. C->_upper=((C)->_upper/*12*/)+(1);
  436. }
  437. /*FI]*/
  438. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  439. /*]*/
  440. }
  441. /*No:FIXED_ARRAY[RUN_FEATURE_3].set_all_with*/
  442. /*No:FIXED_ARRAY[RUN_FEATURE_3].item*/
  443.  
  444.  
  445. T6 r352valid_index(T352* C,T2 a1){
  446. T6 R=0;
  447. R=((0)<=(a1))&&((a1)<=((C)->_upper/*12*/));
  448. return R;
  449. }
  450. /*No:FIXED_ARRAY[RUN_FEATURE_3].count*/
  451. /*No:FIXED_ARRAY[RUN_FEATURE_3].lower*/
  452.  
  453.  
  454. void r352resize(T352* C,T2 a1){
  455. T0* _elt_default=NULL;
  456. T2 _i=0;
  457. T2 _new_capacity=0;
  458. /*[IF*/
  459. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  460. C->_upper=(a1)-(1);
  461. }
  462. else{
  463. _new_capacity=a1;
  464. /*[IF*/
  465. if(((C)->_capacity/*8*/)<(_new_capacity)){
  466. /*[IF*/
  467. if(((C)->_capacity/*8*/)==(0)){
  468. C->_storage=calloc(_new_capacity,sizeof(T0*));
  469. }
  470. else{
  471. C->_storage=r353realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  472. }
  473. /*FI]*/
  474. C->_capacity=_new_capacity;
  475. }
  476. /*FI]*/
  477. _new_capacity=(C)->_upper/*12*/;
  478. C->_upper=(a1)-(1);
  479. _i=(C)->_upper/*12*/;
  480. while (!((_i)==(_new_capacity))) {
  481. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  482. /*]*/
  483. _i=(_i)-(1);
  484. }
  485. }
  486. /*FI]*/
  487. }
  488.  
  489.  
  490. void r352make(T352* C,T2 a1){
  491. /*[IF*/
  492. if((a1)==(0)){
  493. C->_upper=-(1);
  494. }
  495.  else if(((C)->_capacity/*8*/)==(0)){
  496. C->_storage=calloc(a1,sizeof(T0*));
  497. C->_capacity=a1;
  498. C->_upper=(a1)-(1);
  499. }
  500.  else if(((C)->_capacity/*8*/)<(a1)){
  501. C->_storage=calloc(a1,sizeof(T0*));
  502. C->_capacity=a1;
  503. C->_upper=(a1)-(1);
  504. }
  505. else{
  506. C->_upper=(a1)-(1);
  507. /*[IRF3.6clear_all*/{T352* C1=C;
  508. T0* __value=NULL;
  509. /*[IRF3.6set_all_with*/{T352* C2=C1;
  510. T0* c1=__value;
  511. r353set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  512. }/*]*/
  513. }/*]*/
  514. }
  515. /*FI]*/
  516. }
  517.  
  518.  
  519. T6 r352fast_has(T352* C,T0* a1){
  520. T6 R=0;
  521. R=r352valid_index(C,r352fast_index_of(C,a1));
  522. return R;
  523. }
  524.  
  525.  
  526. T2 r352fast_index_of(T352* C,T0* a1){
  527. T2 R=0;
  528. R=r353fast_index_of((C)->_storage/*4*/,a1,(C)->_upper/*12*/);
  529. return R;
  530. }
  531. /*No:FIXED_ARRAY[RUN_FEATURE_3].upper*/
  532. /*No:FIXED_ARRAY[RUN_FEATURE_3].clear*/
  533. /*No:FIXED_ARRAY[RUN_FEATURE_3].capacity*/
  534. /*No:FIXED_ARRAY[RUN_FEATURE_3].put*/
  535. /*No:FIXED_ARRAY[RUN_FEATURE_3].storage*/
  536.  
  537.  
  538. void r345with_capacity(T345* C,T2 a1){
  539. /*[IF*/
  540. if(((C)->_capacity/*8*/)<(a1)){
  541. C->_storage=calloc(a1,sizeof(T0*));
  542. C->_capacity=a1;
  543. }
  544. /*FI]*/
  545. C->_upper=-(1);
  546. }
  547.  
  548.  
  549. T0* r345twin(T345* C){
  550. T0* R=NULL;
  551. R=malloc(sizeof(*C));
  552. *((T345*)R)=M345;
  553. r345copy(((T345*)R),((T0*)C));
  554. return R;
  555. }
  556. /*No:FIXED_ARRAY[ONCE_FUNCTION].clear_all*/
  557.  
  558.  
  559. void r345add_last(T345* C,T0* a1){
  560. T2 _new_capacity=0;
  561. /*[IF*/
  562. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  563. C->_upper=((C)->_upper/*12*/)+(1);
  564. }
  565.  else if(((C)->_capacity/*8*/)==(0)){
  566. C->_storage=calloc(2,sizeof(T0*));
  567. C->_capacity=2;
  568. C->_upper=0;
  569. }
  570. else{
  571. _new_capacity=(2)*((C)->_capacity/*8*/);
  572. C->_storage=r346realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  573. C->_capacity=_new_capacity;
  574. C->_upper=((C)->_upper/*12*/)+(1);
  575. }
  576. /*FI]*/
  577. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  578. /*]*/
  579. }
  580. /*No:FIXED_ARRAY[ONCE_FUNCTION].item*/
  581. /*No:FIXED_ARRAY[ONCE_FUNCTION].set_all_with*/
  582.  
  583.  
  584. T6 r345valid_index(T345* C,T2 a1){
  585. T6 R=0;
  586. R=((0)<=(a1))&&((a1)<=((C)->_upper/*12*/));
  587. return R;
  588. }
  589. /*No:FIXED_ARRAY[ONCE_FUNCTION].count*/
  590. /*No:FIXED_ARRAY[ONCE_FUNCTION].lower*/
  591.  
  592.  
  593. void r345resize(T345* C,T2 a1){
  594. T0* _elt_default=NULL;
  595. T2 _i=0;
  596. T2 _new_capacity=0;
  597. /*[IF*/
  598. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  599. C->_upper=(a1)-(1);
  600. }
  601. else{
  602. _new_capacity=a1;
  603. /*[IF*/
  604. if(((C)->_capacity/*8*/)<(_new_capacity)){
  605. /*[IF*/
  606. if(((C)->_capacity/*8*/)==(0)){
  607. C->_storage=calloc(_new_capacity,sizeof(T0*));
  608. }
  609. else{
  610. C->_storage=r346realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  611. }
  612. /*FI]*/
  613. C->_capacity=_new_capacity;
  614. }
  615. /*FI]*/
  616. _new_capacity=(C)->_upper/*12*/;
  617. C->_upper=(a1)-(1);
  618. _i=(C)->_upper/*12*/;
  619. while (!((_i)==(_new_capacity))) {
  620. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  621. /*]*/
  622. _i=(_i)-(1);
  623. }
  624. }
  625. /*FI]*/
  626. }
  627.  
  628.  
  629. void r345make(T345* C,T2 a1){
  630. /*[IF*/
  631. if((a1)==(0)){
  632. C->_upper=-(1);
  633. }
  634.  else if(((C)->_capacity/*8*/)==(0)){
  635. C->_storage=calloc(a1,sizeof(T0*));
  636. C->_capacity=a1;
  637. C->_upper=(a1)-(1);
  638. }
  639.  else if(((C)->_capacity/*8*/)<(a1)){
  640. C->_storage=calloc(a1,sizeof(T0*));
  641. C->_capacity=a1;
  642. C->_upper=(a1)-(1);
  643. }
  644. else{
  645. C->_upper=(a1)-(1);
  646. /*[IRF3.6clear_all*/{T345* C1=C;
  647. T0* __value=NULL;
  648. /*[IRF3.6set_all_with*/{T345* C2=C1;
  649. T0* c1=__value;
  650. r346set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  651. }/*]*/
  652. }/*]*/
  653. }
  654. /*FI]*/
  655. }
  656.  
  657.  
  658. T6 r345fast_has(T345* C,T0* a1){
  659. T6 R=0;
  660. R=r345valid_index(C,r345fast_index_of(C,a1));
  661. return R;
  662. }
  663.  
  664.  
  665. T2 r345fast_index_of(T345* C,T0* a1){
  666. T2 R=0;
  667. R=r346fast_index_of((C)->_storage/*4*/,a1,(C)->_upper/*12*/);
  668. return R;
  669. }
  670. /*No:FIXED_ARRAY[ONCE_FUNCTION].upper*/
  671. /*No:FIXED_ARRAY[ONCE_FUNCTION].clear*/
  672.  
  673.  
  674. void r345copy(T345* C,T0* a1){
  675. T2 _new_capacity=0;
  676. T2 _other_upper=0;
  677. _other_upper=(((T345*)a1))->_upper/*12*/;
  678. /*[IF*/
  679. if((_other_upper)>=(0)){
  680. _new_capacity=(_other_upper)+(1);
  681. /*[IF*/
  682. if(((C)->_capacity/*8*/)<(_new_capacity)){
  683. C->_capacity=_new_capacity;
  684. C->_storage=calloc(_new_capacity,sizeof(T0*));
  685. }
  686.  else if(((C)->_capacity/*8*/)>(0)){
  687. r346clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  688. }
  689. /*FI]*/
  690. r346copy_from((C)->_storage/*4*/,(((T345*)a1))->_storage/*4*/,_other_upper);
  691. }
  692.  else if(((C)->_capacity/*8*/)>(0)){
  693. r346clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  694. }
  695. /*FI]*/
  696. C->_upper=_other_upper;
  697. }
  698.  
  699.  
  700. T6 r345empty(T345* C){
  701. T6 R=0;
  702. R=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)==(0);
  703. return R;
  704. }
  705. /*No:FIXED_ARRAY[ONCE_FUNCTION].capacity*/
  706. /*No:FIXED_ARRAY[ONCE_FUNCTION].put*/
  707. /*No:FIXED_ARRAY[ONCE_FUNCTION].storage*/
  708.  
  709.  
  710. void r49with_capacity(T49* C,T2 a1){
  711. /*[IF*/
  712. if(((C)->_capacity/*8*/)<(a1)){
  713. C->_storage=calloc(a1,sizeof(T0*));
  714. C->_capacity=a1;
  715. }
  716. /*FI]*/
  717. C->_upper=-(1);
  718. }
  719. /*No:FIXED_ARRAY[RUN_FEATURE_6].clear_all*/
  720.  
  721.  
  722. void r49add_last(T49* C,T0* a1){
  723. T2 _new_capacity=0;
  724. /*[IF*/
  725. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  726. C->_upper=((C)->_upper/*12*/)+(1);
  727. }
  728.  else if(((C)->_capacity/*8*/)==(0)){
  729. C->_storage=calloc(2,sizeof(T0*));
  730. C->_capacity=2;
  731. C->_upper=0;
  732. }
  733. else{
  734. _new_capacity=(2)*((C)->_capacity/*8*/);
  735. C->_storage=r52realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  736. C->_capacity=_new_capacity;
  737. C->_upper=((C)->_upper/*12*/)+(1);
  738. }
  739. /*FI]*/
  740. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  741. /*]*/
  742. }
  743. /*No:FIXED_ARRAY[RUN_FEATURE_6].set_all_with*/
  744. /*No:FIXED_ARRAY[RUN_FEATURE_6].item*/
  745.  
  746.  
  747. T6 r49valid_index(T49* C,T2 a1){
  748. T6 R=0;
  749. R=((0)<=(a1))&&((a1)<=((C)->_upper/*12*/));
  750. return R;
  751. }
  752. /*No:FIXED_ARRAY[RUN_FEATURE_6].lower*/
  753. /*No:FIXED_ARRAY[RUN_FEATURE_6].count*/
  754.  
  755.  
  756. void r49resize(T49* C,T2 a1){
  757. T0* _elt_default=NULL;
  758. T2 _i=0;
  759. T2 _new_capacity=0;
  760. /*[IF*/
  761. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  762. C->_upper=(a1)-(1);
  763. }
  764. else{
  765. _new_capacity=a1;
  766. /*[IF*/
  767. if(((C)->_capacity/*8*/)<(_new_capacity)){
  768. /*[IF*/
  769. if(((C)->_capacity/*8*/)==(0)){
  770. C->_storage=calloc(_new_capacity,sizeof(T0*));
  771. }
  772. else{
  773. C->_storage=r52realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  774. }
  775. /*FI]*/
  776. C->_capacity=_new_capacity;
  777. }
  778. /*FI]*/
  779. _new_capacity=(C)->_upper/*12*/;
  780. C->_upper=(a1)-(1);
  781. _i=(C)->_upper/*12*/;
  782. while (!((_i)==(_new_capacity))) {
  783. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  784. /*]*/
  785. _i=(_i)-(1);
  786. }
  787. }
  788. /*FI]*/
  789. }
  790.  
  791.  
  792. void r49make(T49* C,T2 a1){
  793. /*[IF*/
  794. if((a1)==(0)){
  795. C->_upper=-(1);
  796. }
  797.  else if(((C)->_capacity/*8*/)==(0)){
  798. C->_storage=calloc(a1,sizeof(T0*));
  799. C->_capacity=a1;
  800. C->_upper=(a1)-(1);
  801. }
  802.  else if(((C)->_capacity/*8*/)<(a1)){
  803. C->_storage=calloc(a1,sizeof(T0*));
  804. C->_capacity=a1;
  805. C->_upper=(a1)-(1);
  806. }
  807. else{
  808. C->_upper=(a1)-(1);
  809. /*[IRF3.6clear_all*/{T49* C1=C;
  810. T0* __value=NULL;
  811. /*[IRF3.6set_all_with*/{T49* C2=C1;
  812. T0* c1=__value;
  813. r52set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  814. }/*]*/
  815. }/*]*/
  816. }
  817. /*FI]*/
  818. }
  819.  
  820.  
  821. T6 r49fast_has(T49* C,T0* a1){
  822. T6 R=0;
  823. R=r49valid_index(C,r49fast_index_of(C,a1));
  824. return R;
  825. }
  826.  
  827.  
  828. T2 r49fast_index_of(T49* C,T0* a1){
  829. T2 R=0;
  830. R=r52fast_index_of((C)->_storage/*4*/,a1,(C)->_upper/*12*/);
  831. return R;
  832. }
  833. /*No:FIXED_ARRAY[RUN_FEATURE_6].upper*/
  834. /*No:FIXED_ARRAY[RUN_FEATURE_6].clear*/
  835. /*No:FIXED_ARRAY[RUN_FEATURE_6].capacity*/
  836. /*No:FIXED_ARRAY[RUN_FEATURE_6].put*/
  837. /*No:FIXED_ARRAY[RUN_FEATURE_6].storage*/
  838.  
  839.  
  840. void r380with_capacity(T380* C,T2 a1){
  841. /*[IF*/
  842. if(((C)->_capacity/*8*/)<(a1)){
  843. C->_storage=calloc(a1,sizeof(T0*));
  844. C->_capacity=a1;
  845. }
  846. /*FI]*/
  847. C->_upper=-(1);
  848. }
  849. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].clear_all*/
  850.  
  851.  
  852. void r380add_last(T380* C,T0* a1){
  853. T2 _new_capacity=0;
  854. /*[IF*/
  855. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  856. C->_upper=((C)->_upper/*12*/)+(1);
  857. }
  858.  else if(((C)->_capacity/*8*/)==(0)){
  859. C->_storage=calloc(2,sizeof(T0*));
  860. C->_capacity=2;
  861. C->_upper=0;
  862. }
  863. else{
  864. _new_capacity=(2)*((C)->_capacity/*8*/);
  865. C->_storage=r381realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  866. C->_capacity=_new_capacity;
  867. C->_upper=((C)->_upper/*12*/)+(1);
  868. }
  869. /*FI]*/
  870. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  871. /*]*/
  872. }
  873. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].item*/
  874. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].set_all_with*/
  875. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].count*/
  876.  
  877.  
  878. void r380resize(T380* C,T2 a1){
  879. T0* _elt_default=NULL;
  880. T2 _i=0;
  881. T2 _new_capacity=0;
  882. /*[IF*/
  883. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  884. C->_upper=(a1)-(1);
  885. }
  886. else{
  887. _new_capacity=a1;
  888. /*[IF*/
  889. if(((C)->_capacity/*8*/)<(_new_capacity)){
  890. /*[IF*/
  891. if(((C)->_capacity/*8*/)==(0)){
  892. C->_storage=calloc(_new_capacity,sizeof(T0*));
  893. }
  894. else{
  895. C->_storage=r381realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  896. }
  897. /*FI]*/
  898. C->_capacity=_new_capacity;
  899. }
  900. /*FI]*/
  901. _new_capacity=(C)->_upper/*12*/;
  902. C->_upper=(a1)-(1);
  903. _i=(C)->_upper/*12*/;
  904. while (!((_i)==(_new_capacity))) {
  905. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  906. /*]*/
  907. _i=(_i)-(1);
  908. }
  909. }
  910. /*FI]*/
  911. }
  912.  
  913.  
  914. void r380make(T380* C,T2 a1){
  915. /*[IF*/
  916. if((a1)==(0)){
  917. C->_upper=-(1);
  918. }
  919.  else if(((C)->_capacity/*8*/)==(0)){
  920. C->_storage=calloc(a1,sizeof(T0*));
  921. C->_capacity=a1;
  922. C->_upper=(a1)-(1);
  923. }
  924.  else if(((C)->_capacity/*8*/)<(a1)){
  925. C->_storage=calloc(a1,sizeof(T0*));
  926. C->_capacity=a1;
  927. C->_upper=(a1)-(1);
  928. }
  929. else{
  930. C->_upper=(a1)-(1);
  931. /*[IRF3.6clear_all*/{T380* C1=C;
  932. T0* __value=NULL;
  933. /*[IRF3.6set_all_with*/{T380* C2=C1;
  934. T0* c1=__value;
  935. r381set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  936. }/*]*/
  937. }/*]*/
  938. }
  939. /*FI]*/
  940. }
  941. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].upper*/
  942. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].capacity*/
  943. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].put*/
  944. /*No:FIXED_ARRAY[TYPE_REF_TO_EXP].storage*/
  945.  
  946.  
  947. void r208with_capacity(T208* C,T2 a1){
  948. /*[IF*/
  949. if(((C)->_capacity/*8*/)<(a1)){
  950. C->_storage=calloc(a1,sizeof(T0*));
  951. C->_capacity=a1;
  952. }
  953. /*FI]*/
  954. C->_upper=-(1);
  955. }
  956.  
  957.  
  958. T0* r208twin(T208* C){
  959. T0* R=NULL;
  960. R=malloc(sizeof(*C));
  961. *((T208*)R)=M208;
  962. r208copy(((T208*)R),((T0*)C));
  963. return R;
  964. }
  965. /*No:FIXED_ARRAY[MANIFEST_STRING].clear_all*/
  966.  
  967.  
  968. void r208add_last(T208* C,T0* a1){
  969. T2 _new_capacity=0;
  970. /*[IF*/
  971. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  972. C->_upper=((C)->_upper/*12*/)+(1);
  973. }
  974.  else if(((C)->_capacity/*8*/)==(0)){
  975. C->_storage=calloc(2,sizeof(T0*));
  976. C->_capacity=2;
  977. C->_upper=0;
  978. }
  979. else{
  980. _new_capacity=(2)*((C)->_capacity/*8*/);
  981. C->_storage=r209realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  982. C->_capacity=_new_capacity;
  983. C->_upper=((C)->_upper/*12*/)+(1);
  984. }
  985. /*FI]*/
  986. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  987. /*]*/
  988. }
  989. /*No:FIXED_ARRAY[MANIFEST_STRING].item*/
  990. /*No:FIXED_ARRAY[MANIFEST_STRING].set_all_with*/
  991. /*No:FIXED_ARRAY[MANIFEST_STRING].count*/
  992.  
  993.  
  994. void r208resize(T208* C,T2 a1){
  995. T0* _elt_default=NULL;
  996. T2 _i=0;
  997. T2 _new_capacity=0;
  998. /*[IF*/
  999. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  1000. C->_upper=(a1)-(1);
  1001. }
  1002. else{
  1003. _new_capacity=a1;
  1004. /*[IF*/
  1005. if(((C)->_capacity/*8*/)<(_new_capacity)){
  1006. /*[IF*/
  1007. if(((C)->_capacity/*8*/)==(0)){
  1008. C->_storage=calloc(_new_capacity,sizeof(T0*));
  1009. }
  1010. else{
  1011. C->_storage=r209realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  1012. }
  1013. /*FI]*/
  1014. C->_capacity=_new_capacity;
  1015. }
  1016. /*FI]*/
  1017. _new_capacity=(C)->_upper/*12*/;
  1018. C->_upper=(a1)-(1);
  1019. _i=(C)->_upper/*12*/;
  1020. while (!((_i)==(_new_capacity))) {
  1021. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  1022. /*]*/
  1023. _i=(_i)-(1);
  1024. }
  1025. }
  1026. /*FI]*/
  1027. }
  1028.  
  1029.  
  1030. void r208make(T208* C,T2 a1){
  1031. /*[IF*/
  1032. if((a1)==(0)){
  1033. C->_upper=-(1);
  1034. }
  1035.  else if(((C)->_capacity/*8*/)==(0)){
  1036. C->_storage=calloc(a1,sizeof(T0*));
  1037. C->_capacity=a1;
  1038. C->_upper=(a1)-(1);
  1039. }
  1040.  else if(((C)->_capacity/*8*/)<(a1)){
  1041. C->_storage=calloc(a1,sizeof(T0*));
  1042. C->_capacity=a1;
  1043. C->_upper=(a1)-(1);
  1044. }
  1045. else{
  1046. C->_upper=(a1)-(1);
  1047. /*[IRF3.6clear_all*/{T208* C1=C;
  1048. T0* __value=NULL;
  1049. /*[IRF3.6set_all_with*/{T208* C2=C1;
  1050. T0* c1=__value;
  1051. r209set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  1052. }/*]*/
  1053. }/*]*/
  1054. }
  1055. /*FI]*/
  1056. }
  1057. /*No:FIXED_ARRAY[MANIFEST_STRING].upper*/
  1058.  
  1059.  
  1060. void r208copy(T208* C,T0* a1){
  1061. T2 _new_capacity=0;
  1062. T2 _other_upper=0;
  1063. _other_upper=(((T208*)a1))->_upper/*12*/;
  1064. /*[IF*/
  1065. if((_other_upper)>=(0)){
  1066. _new_capacity=(_other_upper)+(1);
  1067. /*[IF*/
  1068. if(((C)->_capacity/*8*/)<(_new_capacity)){
  1069. C->_capacity=_new_capacity;
  1070. C->_storage=calloc(_new_capacity,sizeof(T0*));
  1071. }
  1072.  else if(((C)->_capacity/*8*/)>(0)){
  1073. r209clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  1074. }
  1075. /*FI]*/
  1076. r209copy_from((C)->_storage/*4*/,(((T208*)a1))->_storage/*4*/,_other_upper);
  1077. }
  1078.  else if(((C)->_capacity/*8*/)>(0)){
  1079. r209clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  1080. }
  1081. /*FI]*/
  1082. C->_upper=_other_upper;
  1083. }
  1084. /*No:FIXED_ARRAY[MANIFEST_STRING].capacity*/
  1085. /*No:FIXED_ARRAY[MANIFEST_STRING].put*/
  1086. /*No:FIXED_ARRAY[MANIFEST_STRING].storage*/
  1087. /*No:ARRAY[BOOLEAN].clear_all*/
  1088.  
  1089.  
  1090. void r354force(T354* C,T6 a1,T2 a2){
  1091. /*[IF*/
  1092. if(((C)->_upper/*8*/)<(a2)){
  1093. r354resize(C,(C)->_lower/*12*/,a2);
  1094. }
  1095.  else if((a2)<((C)->_lower/*12*/)){
  1096. r354resize(C,a2,(C)->_upper/*8*/);
  1097. }
  1098. /*FI]*/
  1099. /*[IRF3.6put*/{T354* C1=C;
  1100. T6 b1=a1;
  1101. T2 b2=a2;
  1102. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  1103. }/*]*/
  1104. }
  1105.  
  1106.  
  1107. T6 r354item(T354* C,T2 a1){
  1108. T6 R=0;
  1109. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  1110. return R;
  1111. }
  1112. /*No:ARRAY[BOOLEAN].set_all_with*/
  1113.  
  1114.  
  1115. T6 r354valid_index(T354* C,T2 a1){
  1116. T6 R=0;
  1117. R=(((C)->_lower/*12*/)<=(a1))&&((a1)<=((C)->_upper/*8*/));
  1118. return R;
  1119. }
  1120.  
  1121.  
  1122. void r354set_slice_with(T354* C,T6 a1,T2 a2,T2 a3){
  1123. T2 _i=0;
  1124. _i=a2;
  1125. while (!((_i)>(a3))) {
  1126. /*[IRF3.6put*/{T354* C1=C;
  1127. T6 b1=a1;
  1128. T2 b2=_i;
  1129. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  1130. }/*]*/
  1131. _i=(_i)+(1);
  1132. }
  1133. }
  1134. /*No:ARRAY[BOOLEAN].lower*/
  1135.  
  1136.  
  1137. void r354resize(T354* C,T2 a1,T2 a2){
  1138. T2 _intersize=0;
  1139. T2 _offset=0;
  1140. T2 _needed=0;
  1141. _needed=((a2)-(a1))+(1);
  1142. /*[IF*/
  1143. if((_needed)>(0)){
  1144. /*[IF*/
  1145. if((_needed)>((C)->_capacity/*4*/)){
  1146. /*[IF*/
  1147. if(((C)->_capacity/*4*/)==(0)){
  1148. C->_storage=calloc(_needed,sizeof(T6));
  1149. C->_capacity=_needed;
  1150. }
  1151. else{
  1152. C->_storage=r355realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_needed);
  1153. C->_capacity=_needed;
  1154. }
  1155. /*FI]*/
  1156. }
  1157. /*FI]*/
  1158. _offset=((C)->_lower/*12*/)-(a1);
  1159. _intersize=((r2min(a2,(C)->_upper/*8*/))-(r2max(a1,(C)->_lower/*12*/)))+(1);
  1160. /*[IF*/
  1161. if((_intersize)>(0)){
  1162. /*[IF*/
  1163. if((_offset)==(0)){
  1164. /*[IF*/
  1165. if((_intersize)<(_needed)){
  1166. r355clear((C)->_storage/*0*/,_intersize,(_needed)-(1));
  1167. }
  1168. /*FI]*/
  1169. }
  1170.  else if((_offset)<(0)){
  1171. r355move((C)->_storage/*0*/,-(_offset),((_intersize)-(_offset))-(1),_offset);
  1172. /*[IF*/
  1173. if((_intersize)<(_needed)){
  1174. r355clear((C)->_storage/*0*/,_intersize,(_needed)-(1));
  1175. }
  1176. /*FI]*/
  1177. }
  1178. else{
  1179. r355move((C)->_storage/*0*/,0,(_intersize)-(1),_offset);
  1180. r355clear((C)->_storage/*0*/,0,(_offset)-(1));
  1181. /*[IF*/
  1182. if(((_intersize)+(_offset))<(_needed)){
  1183. r355clear((C)->_storage/*0*/,(_intersize)+(_offset),(_needed)-(1));
  1184. }
  1185. /*FI]*/
  1186. }
  1187. /*FI]*/
  1188. }
  1189. else{
  1190. r355clear((C)->_storage/*0*/,0,(_needed)-(1));
  1191. }
  1192. /*FI]*/
  1193. }
  1194. /*FI]*/
  1195. C->_lower=a1;
  1196. C->_upper=a2;
  1197. }
  1198.  
  1199.  
  1200. void r354make(T354* C,T2 a1,T2 a2){
  1201. T2 _needed=0;
  1202. C->_lower=a1;
  1203. C->_upper=a2;
  1204. _needed=((a2)-(a1))+(1);
  1205. /*[IF*/
  1206. if((_needed)>(0)){
  1207. /*[IF*/
  1208. if(((C)->_capacity/*4*/)<(_needed)){
  1209. C->_storage=calloc(_needed,sizeof(T6));
  1210. C->_capacity=_needed;
  1211. }
  1212. else{
  1213. /*[IRF3.6clear_all*/{T354* C1=C;
  1214. T6 __value=0;
  1215. /*[IRF3.6set_all_with*/{T354* C2=C1;
  1216. T6 c1=__value;
  1217. r355set_all_with((C2)->_storage/*0*/,c1,((C2)->_upper/*8*/)-((C2)->_lower/*12*/));
  1218. }/*]*/
  1219. }/*]*/
  1220. }
  1221. /*FI]*/
  1222. }
  1223. /*FI]*/
  1224. }
  1225. /*No:ARRAY[BOOLEAN].upper*/
  1226. /*No:ARRAY[BOOLEAN].capacity*/
  1227. /*No:ARRAY[BOOLEAN].put*/
  1228. /*No:ARRAY[BOOLEAN].storage*/
  1229.  
  1230.  
  1231. void r172add_last(T172* C,T2 a1){
  1232. T2 _new_capacity=0;
  1233. /*[IF*/
  1234. if(((C)->_capacity/*4*/)<((r172count(C))+(1))){
  1235. /*[IF*/
  1236. if(((C)->_capacity/*4*/)==(0)){
  1237. C->_capacity=16;
  1238. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T2));
  1239. }
  1240. else{
  1241. _new_capacity=(2)*((C)->_capacity/*4*/);
  1242. C->_storage=r48realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  1243. C->_capacity=_new_capacity;
  1244. }
  1245. /*FI]*/
  1246. }
  1247. /*FI]*/
  1248. C->_upper=((C)->_upper/*8*/)+(1);
  1249. /*[IRF3.6put*/{T172* C1=C;
  1250. T2 b1=a1;
  1251. T2 b2=(C)->_upper/*8*/;
  1252. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  1253. }/*]*/
  1254. }
  1255.  
  1256.  
  1257. T2 r172count(T172* C){
  1258. T2 R=0;
  1259. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  1260. return R;
  1261. }
  1262. /*No:ARRAY[INTEGER].lower*/
  1263. /*No:ARRAY[INTEGER].upper*/
  1264. /*No:ARRAY[INTEGER].capacity*/
  1265. /*No:ARRAY[INTEGER].put*/
  1266. /*No:ARRAY[INTEGER].storage*/
  1267.  
  1268.